home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-04 / mawk10.zip / CAST.C < prev    next >
C/C++ Source or Header  |  1991-10-05  |  9KB  |  394 lines
  1.  
  2. /********************************************
  3. cast.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13.  
  14. /*   $Log:    cast.c,v $
  15.  * Revision 3.4.1.1  91/09/14  17:22:49  brennan
  16.  * VERSION 1.0
  17.  * 
  18.  * Revision 3.4  91/08/16  10:32:08  brennan
  19.  * SW_FP_CHECK for V7 XNX23A
  20.  * 
  21.  * Revision 3.3  91/08/13  06:50:56  brennan
  22.  * VERSION .9994
  23.  * 
  24.  * Revision 3.2  91/06/28  04:16:12  brennan
  25.  * VERSION 0.999
  26.  * 
  27.  * Revision 3.1  91/06/07  10:27:00  brennan
  28.  * VERSION 0.995
  29.  * 
  30.  * Revision 2.5  91/06/04  06:42:57  brennan
  31.  * removed <string.h>
  32.  * 
  33.  * Revision 2.4  91/05/28  15:17:32  brennan
  34.  * removed STRING_BUFF back to temp_buff.string_buff
  35.  * 
  36.  * Revision 2.3  91/05/28  09:04:27  brennan
  37.  * removed main_buff
  38.  * 
  39.  * Revision 2.2  91/05/16  12:19:31  brennan
  40.  * cleanup of machine dependencies
  41.  * 
  42.  * Revision 2.1  91/04/08  08:22:44  brennan
  43.  * VERSION 0.97
  44.  * 
  45. */
  46.  
  47.  
  48. /*  cast.c  */
  49.  
  50. #include "mawk.h"
  51. #include "field.h"
  52. #include "memory.h"
  53. #include "scan.h"
  54. #include "repl.h"
  55.  
  56. int pow2[NUM_CELL_TYPES] = {1,2,4,8,16,32,64,128,256,512} ;
  57.  
  58. void cast1_to_d( cp )
  59.   register CELL *cp ;
  60. {
  61.   switch( cp->type )
  62.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  63.  
  64.     case C_DOUBLE :  return ;
  65.  
  66.     case C_MBSTRN :
  67.     case C_STRING :  
  68.           { register STRING *s = (STRING *) cp->ptr  ;
  69.  
  70. #if FPE_TRAPS_ON  /* look for overflow error */
  71.             errno = 0 ;
  72.             cp->dval = strtod(s->str,(char **)0) ;
  73.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  74.                 rt_error("overflow converting %s to double", s) ;
  75. #else
  76.             cp->dval = strtod(s->str,(char **)0) ;
  77. #endif
  78.             free_STRING(s) ;
  79.           }
  80.             break ;
  81.  
  82.     case C_STRNUM :  
  83.       /* don't need to convert, but do need to free the STRING part */
  84.             free_STRING( string(cp) ) ;
  85.             break ;
  86.  
  87.  
  88.     default :
  89.             bozo("cast on bad type") ;
  90.   }
  91.   cp->type = C_DOUBLE ;
  92. }
  93.  
  94. void cast2_to_d( cp )
  95.   register CELL *cp ;
  96. { register STRING *s ;
  97.  
  98.   switch( cp->type )
  99.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  100.  
  101.     case C_DOUBLE :  goto two ;
  102.     case C_STRNUM :  
  103.             free_STRING( string(cp) ) ;
  104.             break ;
  105.  
  106.     case C_MBSTRN :
  107.     case C_STRING :  
  108.             s = (STRING *) cp->ptr ;
  109.  
  110. #if FPE_TRAPS_ON  /* look for overflow error */
  111.             errno = 0 ;
  112.             cp->dval = strtod(s->str,(char **)0) ;
  113.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  114.                 rt_error("overflow converting %s to double", s) ;
  115. #else
  116.             cp->dval = strtod(s->str,(char **)0) ;
  117. #endif
  118.             free_STRING(s) ;
  119.             break ;
  120.  
  121.     default :
  122.             bozo("cast on bad type") ;
  123.   }
  124.   cp->type = C_DOUBLE ;
  125.  
  126. two:   cp++ ;
  127.   switch( cp->type )
  128.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  129.  
  130.     case C_DOUBLE :  return ;
  131.     case C_STRNUM :  
  132.             free_STRING( string(cp) ) ;
  133.             break ;
  134.  
  135.     case C_MBSTRN :
  136.     case C_STRING :  
  137.             s = (STRING *) cp->ptr ;
  138.  
  139. #if FPE_TRAPS_ON  /* look for overflow error */
  140.             errno = 0 ;
  141.             cp->dval = strtod(s->str,(char **)0) ;
  142.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  143.                 rt_error("overflow converting %s to double", s) ;
  144. #else
  145.             cp->dval = strtod(s->str,(char **)0) ;
  146. #endif
  147.             free_STRING(s) ;
  148.             break ;
  149.  
  150.     default :
  151.             bozo("cast on bad type") ;
  152.   }
  153.   cp->type = C_DOUBLE ;
  154. }
  155.  
  156. void cast1_to_s( cp )
  157.   register CELL *cp ;
  158. { 
  159.   switch( cp->type )
  160.   { case C_NOINIT :  
  161.         null_str.ref_cnt++ ;
  162.         cp->ptr = (PTR) &null_str ;
  163.         break ;
  164.  
  165.     case C_DOUBLE  :
  166.         (void) sprintf(temp_buff.string_buff ,
  167.             string(field+OFMT)->str, cp->dval) ;
  168.  
  169.         cp->ptr = (PTR) new_STRING(temp_buff.string_buff) ;
  170.         break ;
  171.  
  172.     case C_STRING :  return ;
  173.  
  174.     case C_MBSTRN :
  175.     case C_STRNUM :  break ;
  176.  
  177.     default :  bozo("bad type on cast") ;
  178.   }
  179.   cp->type = C_STRING ;
  180. }
  181.  
  182. void cast2_to_s( cp )
  183.   register CELL *cp ;
  184. { 
  185.  
  186.   switch( cp->type )
  187.   { case C_NOINIT : 
  188.         null_str.ref_cnt++ ;
  189.         cp->ptr = (PTR) &null_str ;
  190.         break ;
  191.  
  192.     case C_DOUBLE  :
  193.         (void) sprintf(temp_buff.string_buff,
  194.             string(field+OFMT)->str, cp->dval ) ;
  195.  
  196.         cp->ptr = (PTR) new_STRING(temp_buff.string_buff) ;
  197.         break ;
  198.  
  199.     case C_STRING :  goto two ;
  200.  
  201.     case C_MBSTRN :
  202.     case C_STRNUM :  break ;
  203.  
  204.     default :  bozo("bad type on cast") ;
  205.   }
  206.   cp->type = C_STRING ;
  207.  
  208. two:
  209.   cp++ ;
  210.  
  211.   switch( cp->type )
  212.   { case C_NOINIT :  
  213.         null_str.ref_cnt++ ; 
  214.         cp->ptr = (PTR) &null_str ;
  215.         break ;
  216.  
  217.     case C_DOUBLE  :
  218.         (void) sprintf(temp_buff.string_buff,
  219.             string(field+OFMT)->str, cp->dval) ;
  220.  
  221.         cp->ptr = (PTR) new_STRING(temp_buff.string_buff) ;
  222.         break ;
  223.  
  224.     case C_STRING :  return ;
  225.  
  226.     case C_MBSTRN :
  227.     case C_STRNUM :  break ;
  228.  
  229.     default :  bozo("bad type on cast") ;
  230.   }
  231.   cp->type = C_STRING ;
  232. }
  233.  
  234. void  cast_to_RE( cp )
  235.   register CELL *cp ;
  236. { register PTR p ;
  237.  
  238.   if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  239.  
  240.   p = re_compile( string(cp) ) ;
  241.   free_STRING( string(cp) ) ;
  242.   cp->type = C_RE ;
  243.   cp->ptr = p ;
  244.  
  245. }
  246.  
  247. void  cast_for_split(cp)
  248.   register CELL *cp ;
  249. {
  250.   static char meta[] = "^$.*+?|[]()" ;
  251.   static char xbuff[] = "\\X" ;
  252.   int c ;
  253.   unsigned len ;
  254.     
  255.   if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  256.  
  257.   if ( (len = string(cp)->len) == 1 )
  258.   {
  259.         if ( (c = string(cp)->str[0]) == ' ' )
  260.         { free_STRING(string(cp)) ;
  261.           cp->type = C_SPACE ; 
  262.           return ; 
  263.         }
  264.         else
  265.         if ( strchr(meta, c) )
  266.         { xbuff[1] = c ;
  267.           free_STRING(string(cp)) ;
  268.           cp->ptr = (PTR) new_STRING(xbuff) ;
  269.         }
  270.   }
  271.   else
  272.   if ( len == 0 ) 
  273.   { free_STRING(string(cp)) ;
  274.     cp->type = C_SNULL ; 
  275.     return ; 
  276.   }
  277.  
  278.   cast_to_RE(cp) ;
  279. }
  280.  
  281. /* input: cp-> a CELL of type C_MBSTRN (maybe strnum)
  282.    test it -- casting it to the appropriate type
  283.    which is C_STRING or C_STRNUM
  284. */
  285.  
  286. void check_strnum( cp )
  287.   CELL *cp ;
  288. { char *test ;
  289.   register unsigned char *s , *q ;
  290.  
  291.   cp->type = C_STRING ; /* assume not C_STRNUM */
  292.   s = (unsigned char *) string(cp)->str ;
  293.   q = s + string(cp)->len ;
  294.   while ( scan_code[*s] == SC_SPACE )  s++ ;
  295.   if ( s == q )  return ;
  296.  
  297.   while ( scan_code[ q[-1] ] == SC_SPACE )  q-- ;
  298.   if ( scan_code[ q[-1] ] != SC_DIGIT &&
  299.        q[-1] != '.' )   return ;
  300.  
  301.   switch ( scan_code[*s] )
  302.   {
  303.     case SC_DIGIT :
  304.     case SC_PLUS  :
  305.     case SC_MINUS :
  306.     case SC_DOT   :
  307.  
  308. #if FPE_TRAPS_ON
  309.              errno = 0 ;
  310.              cp->dval  = strtod((char *)s, &test) ;
  311.              if ( errno && cp->dval != 0.0 )
  312.                 rt_error(
  313.                 "overflow converting %s to double" , s) ;
  314. #else
  315.              cp->dval = strtod((char *)s, &test) ;
  316. #endif
  317.  
  318.              if ((char *) q == test )  cp->type = C_STRNUM ;
  319.   }
  320. }
  321.  
  322. /* cast a CELL to a replacement cell */
  323.  
  324. void cast_to_REPL( cp )
  325.   register CELL *cp ;
  326. { register STRING *sval ;
  327.  
  328.   if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  329.   sval = (STRING *) cp->ptr ;
  330.  
  331.   (void) cellcpy(cp, repl_compile(sval)) ;
  332.   free_STRING(sval) ;
  333. }
  334.  
  335.  
  336. #if   HAVE_STRTOD==0
  337.  
  338. static char d_str[] =
  339. "^[ \t]*[-+]?([0-9]+\\.?|\\.[0-9])[0-9]*([eE][-+]?[0-9]+)?" ;
  340.  
  341. static PTR d_ptr ;
  342.  
  343. void strtod_init()
  344. { STRING *sval = new_STRING(d_str) ;
  345.  
  346.   d_ptr = re_compile(sval) ;
  347.   free_STRING(sval) ;
  348. }
  349.  
  350. double strtod( s, endptr)
  351.   char *s , **endptr ;
  352. { double atof() ;
  353.  
  354.   if ( endptr )
  355.   { unsigned len ;
  356.  
  357.     (void) REmatch(s, d_ptr, &len) ;
  358.     *endptr = s + len ;
  359.   }
  360.   return  atof(s) ;
  361. }
  362. #endif  /* HAVE_STRTOD==0 */
  363.  
  364. #if   HAVE_FMOD==0
  365.  
  366. #if SW_FP_CHECK   /* this is V7 and XNX23A specific */
  367.  
  368. double  fmod(x, y)
  369.   double x, y ;
  370. { double modf() ;
  371.   double dtmp, ipart ;
  372.  
  373.   clrerr();
  374.   dtmp = x / y;
  375.   fpcheck();
  376.   return modf(dtmp, &ipart) * y ;
  377. }
  378.  
  379. #else
  380.  
  381. double  fmod(x, y)
  382.   double x, y ;
  383. { double modf() ;
  384.   double ipart ;
  385.  
  386.   return modf(x/y, &ipart) * y ;
  387. }
  388.  
  389. #endif
  390. #endif  
  391.  
  392.  
  393.  
  394.